/**
 * 运动员管理API
 * 提供完整的CRUD操作接口
 */

import { http } from '@/utils/request'

import type {
	AthleteInfo,
	AthleteQueryParams,
	AthleteDetailData,
	AthleteTrainExp,
	AthleteTeamExp,
	AthleteRace,
	AthleteLevel,
	AthleteReward,
	AthleteSeedChose,
	AthleteYearSet,
	PublicitySettingsResponse
} from './types'

// API路径常量 - 直接使用/athlete前缀

const prefix = import.meta.env.VITE_API_ATHLETE

/**
 * 运动员管理API类
 */
export class AthleteAPI {
	/**
	 * 查询运动员列表
	 * @param params 查询参数
	 * @returns 运动员列表响应
	 */
	static async getList(params?: AthleteQueryParams): Promise<ResponseData<{ rows: AthleteInfo[]; total: number }>> {
		return http.get<{ rows: AthleteInfo[]; total: number }>(`${prefix}/list`, params)
	}

	/**
	 * 根据ID查询运动员详情
	 * @param id 运动员ID (支持大数)
	 * @returns 运动员详情响应（包含 info, trains, teams, races, rewards）
	 */
	static async getById(id: string | number): Promise<ResponseData<AthleteDetailData>> {
		return http.get<AthleteDetailData>(`${prefix}/${id}`)
	}

	/**
	 * 新增运动员
	 * @param data 运动员信息
	 * @returns 操作结果
	 */
	static async create(data: Partial<AthleteInfo>): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}`, data)
	}

	/**
	 * 修改运动员信息
	 * @param data 运动员信息
	 * @returns 操作结果
	 */
	static async update(data: Partial<AthleteInfo>): Promise<ResponseData<any>> {
		return http.put<any>(`${prefix}/update`, data)
	}

	/**
	 * 删除运动员
	 * @param id 运动员ID (支持大数)
	 * @returns 操作结果
	 */
	static async deleteById(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`${prefix}/${id}`)
	}

	/**
	 * 批量删除运动员
	 * @param ids 运动员ID数组 (支持大数)
	 * @returns 操作结果
	 */
	static async deleteBatch(ids: Array<string | number>): Promise<ResponseData<any>> {
		return http.delete<any>(`${prefix}/batch`, ids)
	}

	/**
	 * 导出运动员列表
	 * @param params 查询参数
	 * @returns 文件流对象 {filename: string, data: Blob}
	 */
	static async export(params?: AthleteQueryParams): Promise<{ filename: string; data: Blob }> {
		return http.postFile<{ filename: string; data: Blob }>(`${prefix}/export`, params, {
			responseType: 'blob'
		})
	}

	/**
	 * 导入运动员数据
	 * @param file 导入文件
	 * @returns 操作结果
	 */
	static async import(file: File): Promise<ResponseData<any>> {
		const formData = new FormData()
		formData.append('file', file)

		return http.post<any>(`${prefix}/import`, formData, {
			headers: {
				'Content-Type': 'multipart/form-data'
			}
		})
	}

	/**
	 * 下载导入模板
	 * @returns 文件流
	 */
	static async downloadTemplate(): Promise<Blob> {
		return http.request<Blob>({
			url: `${prefix}/template`,
			method: 'get',
			responseType: 'blob'
		})
	}

	/**
	 * 更新运动员状态
	 * @param id 运动员ID (支持大数)
	 * @param status 状态值
	 * @returns 操作结果
	 */
	static async updateStatus(id: string | number, status: number): Promise<ResponseData<any>> {
		return http.put<any>(`${prefix}/status`, {
			id,
			status
		})
	}

	/**
	 * 运动员审核
	 * @param id 运动员ID (支持大数)
	 * @param auditState 审核状态
	 * @param auditAdvice 审核建议
	 * @returns 操作结果
	 */
	static async audit(id: string | number, auditState: string, auditAdvice?: string): Promise<ResponseData<any>> {
		return http.put<any>(`${prefix}/audit`, {
			id,
			auditState,
			auditAdvice
		})
	}

	/**
	 * 运动员复审
	 * @param id 运动员ID (支持大数)
	 * @param recheckState 复审状态
	 * @param recheckAdvice 复审建议
	 * @returns 操作结果
	 */
	static async recheck(id: string | number, recheckState: string, recheckAdvice?: string): Promise<ResponseData<any>> {
		return http.put<any>(`${prefix}/recheck`, {
			id,
			recheckState,
			recheckAdvice
		})
	}

	/**
	 * 上传运动员照片
	 * @param id 运动员ID (支持大数)
	 * @param file 照片文件
	 * @returns 操作结果（包含图片URL）
	 */
	static async uploadPhoto(id: string | number, file: File): Promise<ResponseData<any>> {
		const formData = new FormData()
		formData.append('file', file)
		formData.append('id', String(id))

		return http.post<any>(`${prefix}/photo`, formData, {
			headers: {
				'Content-Type': 'multipart/form-data'
			}
		})
	}

	/**
	 * 创建运动员变更申请
	 * @param data 变更申请数据
	 * @returns 操作结果
	 */
	static async createChange(data: { infoId: number; changeType: number; changeAfter?: number }): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/change`, data)
	}

	/**
	 * 上传运动员证书
	 * @param id 运动员ID (支持大数)
	 * @param file 证书文件
	 * @param type 证书类型 qualifications | otherMaterial
	 * @returns 操作结果
	 */
	static async uploadCertificate(
		id: string | number,
		file: File,
		type: 'qualifications' | 'otherMaterial'
	): Promise<ResponseData<any>> {
		const formData = new FormData()
		formData.append('file', file)
		formData.append('id', String(id))
		formData.append('type', type)

		return http.post<any>(`${prefix}/certificate`, formData, {
			headers: {
				'Content-Type': 'multipart/form-data'
			}
		})
	}

	// 获取注册单位和在训单位的级联数据 query 参数 firstType 和 secondType secondType可以不传 secondType为空时获取第一级数据
	static async getOrgDict(firstType: number, secondType?: number): Promise<ResponseData<any>> {
		const params: any = { firstType }
		if (secondType !== undefined) {
			params.secondType = secondType
		}

		return http.get<any>('/comp/org/dict', params)
	}

	/**
	 * 获取运动员公示信息
	 * @param params 查询参数
	 * @returns 公示信息响应（包含统计数据和公示名单）
	 */
	static async getPublicityInfo(params?: any): Promise<ResponseData<any>> {
		return http.get<any>(`${prefix}/publicity/info`, params)
	}

	// ============ 训练经历相关API ============

	/**
	 * 查询运动员训练经历列表
	 * @param infoId 运动员ID
	 * @returns 训练经历列表
	 */
	static async getTrainExpList(infoId: string | number): Promise<ResponseData<AthleteTrainExp[]>> {
		return http.get<AthleteTrainExp[]>('/comp/train/exp/list', { infoId })
	}

	/**
	 * 新增训练经历
	 * @param data 训练经历信息
	 * @returns 操作结果
	 */
	static async createTrainExp(data: Partial<AthleteTrainExp>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/train/exp', data)
	}

	/**
	 * 修改训练经历
	 * @param data 训练经历信息
	 * @returns 操作结果
	 */
	static async updateTrainExp(data: Partial<AthleteTrainExp>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/train/exp', data)
	}

	/**
	 * 删除训练经历
	 * @param id 训练经历ID
	 * @returns 操作结果
	 */
	static async deleteTrainExp(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/train/exp/${id}`)
	}

	// ============ 集训经历相关API ============

	/**
	 * 查询运动员集训经历列表
	 * @param infoId 运动员ID
	 * @returns 集训经历列表
	 */
	static async getTeamExpList(infoId: string | number): Promise<ResponseData<AthleteTeamExp[]>> {
		return http.get<AthleteTeamExp[]>('/comp/team/list', { infoId })
	}

	/**
	 * 新增集训经历
	 * @param data 集训经历信息
	 * @returns 操作结果
	 */
	static async createTeamExp(data: Partial<AthleteTeamExp>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/team', data)
	}

	/**
	 * 修改集训经历
	 * @param data 集训经历信息
	 * @returns 操作结果
	 */
	static async updateTeamExp(data: Partial<AthleteTeamExp>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/team', data)
	}

	/**
	 * 删除集训经历
	 * @param id 集训经历ID
	 * @returns 操作结果
	 */
	static async deleteTeamExp(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/team/${id}`)
	}

	// ============ 比赛信息相关API ============

	/**
	 * 查询运动员比赛信息列表
	 * @param infoId 运动员ID
	 * @returns 比赛信息列表
	 */
	static async getRaceList(infoId: string | number): Promise<ResponseData<AthleteRace[]>> {
		return http.get<AthleteRace[]>('/comp/race/list', { infoId })
	}

	/**
	 * 新增比赛信息
	 * @param data 比赛信息
	 * @returns 操作结果
	 */
	static async createRace(data: Partial<AthleteRace>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/race', data)
	}

	/**
	 * 修改比赛信息
	 * @param data 比赛信息
	 * @returns 操作结果
	 */
	static async updateRace(data: Partial<AthleteRace>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/race', data)
	}

	/**
	 * 删除比赛信息
	 * @param id 比赛信息ID
	 * @returns 操作结果
	 */
	static async deleteRace(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/race/${id}`)
	}

	// ============ 运动员等级相关API ============

	/**
	 * 查询运动员等级列表
	 * @param infoId 运动员ID
	 * @returns 等级列表
	 */
	static async getLevelList(infoId: string | number): Promise<ResponseData<AthleteLevel[]>> {
		return http.get<AthleteLevel[]>('/comp/level/list', { infoId })
	}

	/**
	 * 新增运动员等级
	 * @param data 等级信息
	 * @returns 操作结果
	 */
	static async createLevel(data: Partial<AthleteLevel>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/level', data)
	}

	/**
	 * 修改运动员等级
	 * @param data 等级信息
	 * @returns 操作结果
	 */
	static async updateLevel(data: Partial<AthleteLevel>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/level', data)
	}

	/**
	 * 删除运动员等级
	 * @param id 等级ID
	 * @returns 操作结果
	 */
	static async deleteLevel(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/level/${id}`)
	}

	// ============ 运动员奖罚相关API ============

	/**
	 * 查询运动员奖罚列表
	 * @param infoId 运动员ID
	 * @returns 奖罚列表
	 */
	static async getRewardList(infoId: string | number): Promise<ResponseData<AthleteReward[]>> {
		return http.get<AthleteReward[]>('/comp/reward/list', { infoId })
	}

	/**
	 * 新增运动员奖罚
	 * @param data 奖罚信息
	 * @returns 操作结果
	 */
	static async createReward(data: Partial<AthleteReward>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/reward', data)
	}

	/**
	 * 修改运动员奖罚
	 * @param data 奖罚信息
	 * @returns 操作结果
	 */
	static async updateReward(data: Partial<AthleteReward>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/reward', data)
	}

	/**
	 * 删除运动员奖罚
	 * @param id 奖罚ID
	 * @returns 操作结果
	 */
	static async deleteReward(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/reward/${id}`)
	}

	// ============ 运动员苗子选拔相关API ============

	/**
	 * 查询运动员苗子选拔列表
	 * @param infoId 运动员ID
	 * @returns 苗子选拔列表
	 */
	static async getSeedChoseList(infoId: string | number): Promise<ResponseData<{ rows: AthleteSeedChose[]; total: number }>> {
		return http.get<{ rows: AthleteSeedChose[]; total: number }>('/comp/chose/list', { infoId })
	}

	/**
	 * 新增运动员苗子选拔
	 * @param data 苗子选拔信息
	 * @returns 操作结果
	 */
	static async createSeedChose(data: Partial<AthleteSeedChose>): Promise<ResponseData<any>> {
		return http.post<any>('/comp/chose', data)
	}

	/**
	 * 修改运动员苗子选拔
	 * @param data 苗子选拔信息
	 * @returns 操作结果
	 */
	static async updateSeedChose(data: Partial<AthleteSeedChose>): Promise<ResponseData<any>> {
		return http.put<any>('/comp/chose', data)
	}

	/**
	 * 删除运动员苗子选拔
	 * @param id 苗子选拔ID
	 * @returns 操作结果
	 */
	static async deleteSeedChose(id: string | number): Promise<ResponseData<any>> {
		return http.delete<any>(`/comp/chose/${id}`)
	}

	// ============ 年度确认设置相关API ============

	/**
	 * 获取年度确认设置
	 * @returns 年度设置信息
	 */
	static async getYearSet(): Promise<ResponseData<AthleteYearSet>> {
		return http.get<AthleteYearSet>(`${prefix}/year/set`)
	}

	/**
	 * 保存年度确认设置
	 * @param data 年度设置信息
	 * @returns 操作结果
	 */
	static async saveYearSet(data: Partial<AthleteYearSet>): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/year/set`, data)
	}

	// ============ 年度确认相关API ============

	/**
	 * 获取年度确认列表
	 * @param params 查询参数
	 * @returns 运动员列表响应
	 */
	static async getYearConfirmList(params?: AthleteQueryParams): Promise<ResponseData<{ rows: AthleteInfo[]; total: number }>> {
		return http.get<{ rows: AthleteInfo[]; total: number }>(`${prefix}/year/confirm/list`, params)
	}

	/**
	 * 对单个运动员发起确认
	 * @param athleteId 运动员ID
	 * @returns 操作结果
	 */
	static async launchYearConfirm(athleteId: string | number): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/year/confirm/launch`, null, {
			params: { athleteId }
		})
	}

	/**
	 * 批量发起确认
	 * @param athleteIds 运动员ID数组
	 * @returns 操作结果
	 */
	static async batchLaunchYearConfirm(athleteIds: Array<string | number>): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/year/confirm/batchLaunch`, null, {
			params: { athleteIds: athleteIds.join(',') }
		})
	}

	/**
	 * 一键发起确认
	 * @returns 操作结果
	 */
	static async allLaunchYearConfirm(): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/year/confirm/allLaunch`)
	}

	/**
	 * 获取当前登录用户的运动员信息
	 * @returns 运动员信息（包含yearId字段用于判断是否需要年度确认）
	 */
	static async getCurrentUserInfo(): Promise<ResponseData<AthleteInfo | null>> {
		return http.get<AthleteInfo | null>(`${prefix}/info`)
	}

	/**
	 * 年度确认提交
	 * @param data 运动员信息（与注册时参数相同）
	 * @returns 操作结果
	 */
	static async yearConfirm(data: Partial<AthleteInfo>): Promise<ResponseData<any>> {
		return http.put<any>(`${prefix}/year/confirm`, data)
	}

	// ============ 公示管理相关API ============

	/**
	 * 设置自动公示
	 * @param autoPublicity 是否自动公示 (0=不自动公示, 1=自动公示)
	 * @param publicityType 公示类型 (1=注册公示, 2=变更公示)
	 * @returns 操作结果
	 */
	static async setAutoPublicity(autoPublicity: number, publicityType: number): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/publicity/set`, null, {
			params: {
				autoPublicity,
				publicityType
			}
		})
	}

	/**
	 * 发布公示
	 * @param publicityType 公示类型 (1=注册公示, 2=变更公示)
	 * @returns 操作结果
	 */
	static async publishPublicity(publicityType: number): Promise<ResponseData<any>> {
		return http.post<any>(`${prefix}/publicity/publish`, null, {
			params: {
				publicityType
			}
		})
	}

	/**
	 * 查询是否自动公示
	 * @param publicityType 公示类型 (1=注册公示, 2=变更公示)
	 * @returns 自动公示配置响应
	 */
	static async getAutoPublicity(publicityType: number): Promise<ResponseData<number>> {
		return http.get<number>(`${prefix}/publicity/get`, {
			publicityType
		})
	}
}

/**
 * 便捷的API方法导出（兼容函数式调用）
 */

/**
 * 查询运动员列表
 */
export const getAthleteListApi = AthleteAPI.getList

/**
 * 查询运动员详情
 */
export const getAthleteByIdApi = AthleteAPI.getById

/**
 * 新增运动员
 */
export const createAthleteApi = AthleteAPI.create

/**
 * 修改运动员
 */
export const updateAthleteApi = AthleteAPI.update

/**
 * 删除运动员
 */
export const deleteAthleteApi = AthleteAPI.deleteById

/**
 * 批量删除运动员
 * @description 暂时不支持批量删除
 */
export const deleteBatchAthleteApi = AthleteAPI.deleteBatch

/**
 * 导出运动员列表
 */
export const exportAthleteListApi = AthleteAPI.export

/**
 * 导入运动员数据
 */
export const importAthleteDataApi = AthleteAPI.import

/**
 * 下载导入模板
 */
export const downloadAthleteTemplateApi = AthleteAPI.downloadTemplate

/**
 * 更新运动员状态
 */
export const updateAthleteStatusApi = AthleteAPI.updateStatus

/**
 * 运动员审核
 */
export const auditAthleteApi = AthleteAPI.audit

/**
 * 运动员复审
 */
export const recheckAthleteApi = AthleteAPI.recheck

/**
 * 获取注册单位和在训单位的级联数据 的 二级数据
 */
export const getOrgDictApi = AthleteAPI.getOrgDict

/**
 * 获取运动员公示信息
 */
export const getPublicityInfoApi = AthleteAPI.getPublicityInfo

/**
 * 查询运动员训练经历列表
 */
export const getTrainExpListApi = AthleteAPI.getTrainExpList

/**
 * 新增训练经历
 */
export const createTrainExpApi = AthleteAPI.createTrainExp

/**
 * 修改训练经历
 */
export const updateTrainExpApi = AthleteAPI.updateTrainExp

/**
 * 删除训练经历
 */
export const deleteTrainExpApi = AthleteAPI.deleteTrainExp

/**
 * 查询运动员集训经历列表
 */
export const getTeamExpListApi = AthleteAPI.getTeamExpList

/**
 * 新增集训经历
 */
export const createTeamExpApi = AthleteAPI.createTeamExp

/**
 * 修改集训经历
 */
export const updateTeamExpApi = AthleteAPI.updateTeamExp

/**
 * 删除集训经历
 */
export const deleteTeamExpApi = AthleteAPI.deleteTeamExp

/**
 * 查询运动员比赛信息列表
 */
export const getRaceListApi = AthleteAPI.getRaceList

/**
 * 新增比赛信息
 */
export const createRaceApi = AthleteAPI.createRace

/**
 * 修改比赛信息
 */
export const updateRaceApi = AthleteAPI.updateRace

/**
 * 删除比赛信息
 */
export const deleteRaceApi = AthleteAPI.deleteRace

/**
 * 查询运动员等级列表
 */
export const getLevelListApi = AthleteAPI.getLevelList

/**
 * 新增运动员等级
 */
export const createLevelApi = AthleteAPI.createLevel

/**
 * 修改运动员等级
 */
export const updateLevelApi = AthleteAPI.updateLevel

/**
 * 删除运动员等级
 */
export const deleteLevelApi = AthleteAPI.deleteLevel

/**
 * 查询运动员奖罚列表
 */
export const getRewardListApi = AthleteAPI.getRewardList

/**
 * 新增运动员奖罚
 */
export const createRewardApi = AthleteAPI.createReward

/**
 * 修改运动员奖罚
 */
export const updateRewardApi = AthleteAPI.updateReward

/**
 * 删除运动员奖罚
 */
export const deleteRewardApi = AthleteAPI.deleteReward

/**
 * 查询运动员苗子选拔列表
 */
export const getSeedChoseListApi = AthleteAPI.getSeedChoseList

/**
 * 新增运动员苗子选拔
 */
export const createSeedChoseApi = AthleteAPI.createSeedChose

/**
 * 修改运动员苗子选拔
 */
export const updateSeedChoseApi = AthleteAPI.updateSeedChose

/**
 * 删除运动员苗子选拔
 */
export const deleteSeedChoseApi = AthleteAPI.deleteSeedChose

/**
 * 获取年度确认设置
 */
export const getYearSetApi = AthleteAPI.getYearSet

/**
 * 保存年度确认设置
 */
export const saveYearSetApi = AthleteAPI.saveYearSet

/**
 * 获取年度确认列表
 */
export const getYearConfirmListApi = AthleteAPI.getYearConfirmList

/**
 * 对单个运动员发起确认
 */
export const launchYearConfirmApi = AthleteAPI.launchYearConfirm

/**
 * 批量发起确认
 */
export const batchLaunchYearConfirmApi = AthleteAPI.batchLaunchYearConfirm

/**
 * 一键发起确认
 */
export const allLaunchYearConfirmApi = AthleteAPI.allLaunchYearConfirm

/**
 * 创建运动员变更申请
 */
export const createAthleteChangeApi = AthleteAPI.createChange

/**
 * 获取当前登录用户的运动员信息
 */
export const getCurrentUserInfoApi = AthleteAPI.getCurrentUserInfo

/**
 * 年度确认提交
 */
export const yearConfirmApi = AthleteAPI.yearConfirm

/**
 * 设置自动公示
 */
export const setAutoPublicityApi = AthleteAPI.setAutoPublicity

/**
 * 发布公示
 */
export const publishPublicityApi = AthleteAPI.publishPublicity

/**
 * 查询是否自动公示
 */
export const getAutoPublicityApi = AthleteAPI.getAutoPublicity

// 默认导出API类
export default AthleteAPI
